home *** CD-ROM | disk | FTP | other *** search
/ Nejlepší České Hry / Nej české hry.iso / hry / plane arcade / planearcade.exe / tank3.bmp / types.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-08-21  |  19.4 KB  |  865 lines
  1. #include "main.h"
  2.  
  3.  
  4.  
  5. //-----------------------------------------------------------------------------
  6. // Name: GetColor()
  7. // Desc: pretazena funkcia
  8. //-----------------------------------------------------------------------------
  9. COLOR GetColor(float R,float G,float B)
  10. {
  11.     return GetColor(1.0f,R,G,B);
  12. }
  13.  
  14. //-----------------------------------------------------------------------------
  15. // Name: GetColor()
  16. // Desc: funckia vrati COLOR
  17. //-----------------------------------------------------------------------------
  18. COLOR GetColor(float A,float R,float G,float B)
  19. {
  20.     COLOR Vys;
  21.  
  22.     Vys.R = R;
  23.     Vys.B = B;
  24.     Vys.G = G;
  25.     Vys.A = A;
  26.  
  27.     return Vys;
  28. }
  29.  
  30. //-----------------------------------------------------------------------------
  31. // Name: GetColor()
  32. // Desc: vytvori D3D maticu  
  33. //-----------------------------------------------------------------------------
  34. D3DXMATRIXA16 GetMatrix(VECTOR3D Pos,VECTOR3D Rot,VECTOR3D Sca)
  35. {
  36.  
  37.     D3DXMATRIXA16 matAll;
  38.  
  39.     D3DXMATRIXA16 matRot; 
  40.     D3DXMATRIXA16 matPos;
  41.     D3DXMATRIXA16 matSca;
  42.             
  43.     //rotation//
  44.     D3DXMatrixRotationYawPitchRoll(&matRot,Rot.Y,Rot.X,Rot.Z);
  45.  
  46.     //position//
  47.     D3DXMatrixTranslation( &matPos, Pos.X,Pos.Y,Pos.Z);
  48.  
  49.     //scaling//
  50.     D3DXMatrixScaling( &matSca, Sca.X,Sca.Y,Sca.Z);
  51.  
  52.     D3DXMatrixIdentity(&matAll);
  53.     D3DXMatrixMultiply(&matAll,&matAll,&matSca);
  54.     D3DXMatrixMultiply(&matAll,&matAll,&matRot);
  55.     D3DXMatrixMultiply(&matAll,&matAll,&matPos);
  56.  
  57.     return matAll;
  58.  
  59. }
  60.  
  61. //-----------------------------------------------------------------------------
  62. // Name: Sub()
  63. // Desc: Rozdiel vektorov
  64. //-----------------------------------------------------------------------------
  65. void Sub(VECTOR3D * V,VECTOR3D A,VECTOR3D B) 
  66. {
  67.  
  68.     V->X = A.X - B.X;
  69.     V->Y = A.Y - B.Y;
  70.     V->Z = A.Z - B.Z;
  71.  
  72. }
  73.  
  74.  
  75. //-----------------------------------------------------------------------------
  76. // Name: Add()
  77. // Desc: spocita vektory
  78. //-----------------------------------------------------------------------------
  79. void Add(VECTOR3D * V,VECTOR3D A,VECTOR3D B) 
  80. {
  81.  
  82.     V->X = A.X + B.X;
  83.     V->Y = A.Y + B.Y;
  84.     V->Z = A.Z + B.Z;
  85.  
  86. }
  87.  
  88. //-----------------------------------------------------------------------------
  89. // Name: Mul()
  90. // Desc: Vynasobi vektory
  91. //-----------------------------------------------------------------------------
  92. void Mul(VECTOR3D * V,VECTOR3D A,VECTOR3D B) 
  93. {
  94.  
  95.     V->X = A.X * B.X;
  96.     V->Y = A.Y * B.Y;
  97.     V->Z = A.Z * B.Z;
  98.  
  99. }
  100.  
  101. //-----------------------------------------------------------------------------
  102. // Name: Cross()
  103. // Desc: Vypocita normalu dvoch vektorov A,B
  104. //-----------------------------------------------------------------------------
  105. void Cross(VECTOR3D * V,VECTOR3D A,VECTOR3D B)
  106.  {
  107.  
  108.     V->X = B.Y * A.Z - A.Y * B.Z; 
  109.     V->Y = B.Z * A.X - A.Z * B.X; 
  110.     V->Z = B.X * A.Y - A.X * B.Y;
  111.  
  112. }
  113.  
  114. //-----------------------------------------------------------------------------
  115. // Name: Dot()
  116. // Desc: skalarny sucin
  117. //-----------------------------------------------------------------------------
  118. float Dot(VECTOR3D A,VECTOR3D B)
  119. {
  120.     return (B.X * A.X) + (B.Y * A.Y) + (B.Z * A.Z);
  121. }
  122.  
  123.  
  124. //-----------------------------------------------------------------------------
  125. // Name: Absolute()
  126. // Desc: Vypocita absolutnu hodnotu vektora
  127. //-----------------------------------------------------------------------------
  128. float Absolute(VECTOR3D V) 
  129. {
  130.     return (float)
  131.         ( sqrt(
  132.         (V.X * V.X) + 
  133.         (V.Y * V.Y) + 
  134.         (V.Z * V.Z)
  135.         ) );
  136. }
  137.  
  138. //-----------------------------------------------------------------------------
  139. // Name: Normalize()
  140. // Desc: Upravy vektor tak aby jeho Absolutna hodnota = 1
  141. //-----------------------------------------------------------------------------
  142. void Normalize(VECTOR3D * V) 
  143. {
  144.  
  145.     float Abs = Absolute(*V);
  146.     
  147.     V->X = V->X / Abs;
  148.     V->Y = V->Y / Abs;
  149.     V->Z = V->Z / Abs;
  150.  
  151. }
  152.  
  153.  
  154.  
  155. //-----------------------------------------------------------------------------
  156. // Name: Get3D()
  157. // Desc: Vrati VECTOR3D
  158. //---------------------------------------------------------------------------
  159. VECTOR3D Get3D(float X,float Y,float Z) 
  160. {
  161.  
  162.     VECTOR3D V;
  163.  
  164.     V.X = X;
  165.     V.Y = Y;
  166.     V.Z = Z;
  167.  
  168.     return V;
  169. }
  170.  
  171. //-----------------------------------------------------------------------------
  172. // Name: Get2D()
  173. // Desc: Vrati VECTOR2D
  174. //---------------------------------------------------------------------------
  175. VECTOR2D Get2D(float X,float Y) 
  176. {
  177.  
  178.     VECTOR2D V;
  179.  
  180.     V.X = X;
  181.     V.Y = Y;
  182.  
  183.     return V;
  184. }
  185.  
  186.  
  187. //-----------------------------------------------------------------------------
  188. // Name: Project()
  189. // Desc: Premietne 3D bod na 2D obrazovku
  190. //---------------------------------------------------------------------------
  191. VECTOR3D Project(VECTOR3D B)
  192. {
  193.     VECTOR3D V;
  194.  
  195.     D3DXVECTOR3 In;
  196.     D3DXVECTOR3 Out;
  197.  
  198.     D3DXMATRIX world;
  199.     
  200.     //vytvori prazdnu maticu
  201.     world = GetMatrix(Get3D(0.0f,0.0f,0.0f),Get3D(0.0f,0.0f,0.0f),Get3D(1.0f,1.0f,1.0f));
  202.     
  203.     In.x = B.X;
  204.     In.y = B.Y;
  205.     In.z = B.Z;
  206.  
  207.     D3DXVec3Project(&Out,&In,&Engine.Viewport,&matProj,&matView,&world);
  208.  
  209.  
  210.     if (Out.x < 0) Out.x = -1000;
  211.     if (Out.y < 0) Out.y = -1000; 
  212.  
  213.     if (Out.x > Engine.Width) Out.x = -1000;
  214.     if (Out.y > Engine.Height) Out.y = -1000;
  215.     
  216.     if (Out.z < Engine.Max) 
  217.     {
  218.      V.X = Out.x ;
  219.      V.Y = Out.y ;
  220.      V.Z = 0.0f ;
  221.     }
  222.     else
  223.     {
  224.      V.X = -1000 ;
  225.      V.Y = -1000;
  226.      V.Z = 0.0f;
  227.     }
  228.  
  229.     return V;
  230.  
  231. }
  232.  
  233.  
  234. //-----------------------------------------------------------------------------
  235. // Name: Project()
  236. // Desc: Premietne 2D bod do 3D priestoru
  237. //---------------------------------------------------------------------------
  238. VECTOR3D UnProject(VECTOR3D B)
  239. {
  240.     
  241.     VECTOR3D V;
  242.  
  243.     D3DXVECTOR3 In;
  244.     D3DXVECTOR3 Out;
  245.  
  246.     D3DXMATRIX world;
  247.     
  248.     world = GetMatrix(Get3D(0.0f,0.0f,0.0f),Get3D(0.0f,0.0f,0.0f),Get3D(1.0f,1.0f,1.0f));
  249.     
  250.     In.x = B.X;
  251.     In.y = B.Y;
  252.     In.z = 0.0f;
  253.  
  254.     D3DXVec3Unproject(&Out,&In,&Engine.Viewport,&matProj,&matView,&world);
  255.  
  256.     V.X = Out.x ;
  257.     V.Y = Out.y ;
  258.     V.Z = Out.z ;
  259.  
  260.     return V;
  261. }
  262.  
  263.  
  264. //------------------------------------------------------------------
  265. // Name: GetPlane
  266. // Desc: vrati PLANE
  267. //------------------------------------------------------------------
  268. PLANE GetPlane(VECTOR3D Normal,float D)
  269. {
  270.     PLANE P;
  271.  
  272.     P.Normal = Normal;
  273.     P.D = D;
  274.  
  275.     return P;
  276. }
  277.  
  278. //------------------------------------------------------------------
  279. // Name: CreatePlaneFace
  280. // Desc: Vytvori rovinu z trojholnika udaneho bodmi B1,B2,B3
  281. //------------------------------------------------------------------
  282. PLANE  CreatePlaneFace(VECTOR3D B1,VECTOR3D B2,VECTOR3D B3)
  283. {
  284.     VECTOR3D V1,V2;
  285.     PLANE P;
  286.  
  287.     Sub(&V1,B1,B2);
  288.     Sub(&V2,B3,B2);
  289.  
  290.     Cross(&P.Normal,V2,V1);
  291.     
  292.     Normalize(&P.Normal);
  293.  
  294.     P.D = -(P.Normal.X*B2.X)
  295.           -(P.Normal.Y*B2.Y)
  296.           -(P.Normal.Z*B2.Z);
  297.  
  298.     return P;
  299.  
  300.     
  301. }
  302.  
  303. //------------------------------------------------------------------
  304. // Name: CreatePlanePoint
  305. // Desc: Vytvori rovinu z dvoch bodov B1 lezi na rovine 
  306. //       rozdiel B2 a B1 vytvara normalu
  307. //------------------------------------------------------------------
  308. PLANE  CreatePlanePoint(VECTOR3D B1,VECTOR3D B2)
  309. {
  310.     PLANE P;
  311.  
  312.     Sub(&P.Normal,B2,B1);
  313.  
  314.     Normalize(&P.Normal);
  315.  
  316.     P.D = -(P.Normal.X*B1.X)
  317.           -(P.Normal.Y*B1.Y)
  318.           -(P.Normal.Z*B1.Z);
  319.  
  320.     return P;
  321.  
  322. }
  323.  
  324. //------------------------------------------------------------------
  325. // Name: PointPlane
  326. // Desc: Zisti na ktorej strane roviny lezi bod, ak na zadnej vysledok
  327. //       je mensi ako nula ak na prednej vysledok je vacsi ako nula
  328. //------------------------------------------------------------------
  329. float  PointPlane(PLANE P,VECTOR3D B)
  330. {
  331.     float Vys;
  332.  
  333.     Vys = (P.Normal.X*B.X)
  334.          +(P.Normal.Y*B.Y)
  335.          +(P.Normal.Z*B.Z)
  336.          +P.D;
  337.  
  338.     return Vys;
  339.  
  340. }
  341.  
  342. //------------------------------------------------------------------
  343. // Name: CalcPriesEdge
  344. // Desc: Vypocita priesecnik roviny P s priamkov udanou B1 a B2, priesecnik,
  345. //       sa ulozi do B, funckia vrati true ak ma priamka priesecnik s rovinou P
  346. //------------------------------------------------------------------
  347. bool CalcPriesEdge(VECTOR3D *B,PLANE P,VECTOR3D B1,VECTOR3D B2)
  348. {
  349.  
  350.     float Vys1 = PointPlane(P,B1);
  351.     float Vys2 = PointPlane(P,B2);
  352.  
  353.     if ((Vys1<0.0f) && (Vys2>0.0f) ||
  354.             (Vys1>0.0f) && (Vys2<0.0f))
  355.     {
  356.  
  357.         //smerovy vektor priamky
  358.         VECTOR3D Sme;
  359.  
  360.         Sub(&Sme,B2,B1);
  361.         Normalize(&Sme);
  362.  
  363.         //vypocet parametru T pomocou ktoreho sa zisti priesecnik
  364.         float T = (-P.D - (P.Normal.X*B1.X) - (P.Normal.Y*B1.Y) - (P.Normal.Z*B1.Z))/
  365.                  ((P.Normal.X*Sme.X) + (P.Normal.Y*Sme.Y) + (P.Normal.Z*Sme.Z));
  366.     
  367.         //priesecnik
  368.         B->X = B1.X + (Sme.X * T);
  369.         B->Y = B1.Y + (Sme.Y * T);
  370.         B->Z = B1.Z + (Sme.Z * T);
  371.  
  372.         return true;
  373.     }
  374.     else
  375.     {
  376.         return false;
  377.     }
  378. }
  379.  
  380.  
  381. //------------------------------------------------------------------
  382. // Name: CalcPries
  383. // Desc: Vypocita priesecnik troch rovin, priesecnik sa ulozi do B, 
  384. //       v pripade ze roviny nemaju jeden priesecnik funkcia vrati false
  385. //------------------------------------------------------------------
  386. bool CalcPriesPlane(VECTOR3D *B,PLANE P1,PLANE P2,PLANE P3)
  387. {
  388.     
  389.     //zisti ci su roviny rovnobe₧ne
  390.     float denom;
  391.     VECTOR3D Pom1;
  392.     Cross(&Pom1,P2.Normal,P3.Normal);
  393.     denom = Dot(Pom1,P1.Normal);
  394.  
  395.     if (denom == 0.0f)
  396.     {
  397.         return false;
  398.     }
  399.  
  400.     //zistenie priesecnika
  401.     VECTOR3D C1,C2,C3;
  402.     VECTOR3D A1,A2,A3;
  403.  
  404.     Cross(&C1,P2.Normal,P3.Normal);
  405.     Cross(&C2,P3.Normal,P1.Normal);
  406.     Cross(&C3,P1.Normal,P2.Normal);
  407.  
  408.     A1.X = C1.X * P1.D;
  409.     A1.Y = C1.Y * P1.D;
  410.     A1.Z = C1.Z * P1.D;
  411.  
  412.     A2.X = C2.X * P2.D;
  413.     A2.Y = C2.Y * P2.D;
  414.     A2.Z = C2.Z * P2.D;
  415.  
  416.     A3.X = C3.X * P3.D;
  417.     A3.Y = C3.Y * P3.D;
  418.     A3.Z = C3.Z * P3.D;
  419.  
  420.     B->X = -A1.X - A2.X - A3.X;
  421.     B->Y = -A1.Y - A2.Y - A3.Y;
  422.     B->Z = -A1.Z - A2.Z - A3.Z;
  423.  
  424.     B->X = B->X /  denom;
  425.     B->Y = B->Y /  denom;
  426.     B->Z = B->Z /  denom;
  427.  
  428.     return true;
  429.     
  430. }
  431.  
  432.  
  433. //------------------------------------------------------------------
  434. // Name: CalcAngleCentre()
  435. // Desc: Vypocitaj uhol zadany bodmi, pricom vrchol je S
  436. //------------------------------------------------------------------
  437. float CalcAngleCentre(VECTOR3D S,VECTOR3D P1, VECTOR3D P2)
  438. {
  439.     //pomocne vektory
  440.     VECTOR3D A;
  441.     VECTOR3D B;
  442.     
  443.     float medzi; //medzivypocet
  444.     float vysledok;  //konecky vysledok
  445.  
  446.     //z troch bodov vypoΦφtame de vektory 
  447.     //z ktor²ch vypoΦφtame uhol medzi 
  448.     Sub(&A,P1,S);
  449.     Sub(&B,P2,S);
  450.  
  451.     //vypocet absolutnych hodnot vektorov
  452.     float AbsA = Absolute(A);
  453.     float AbsB = Absolute(B);
  454.  
  455.     //skalarny sucin / absolutne hodnoty vektorov
  456.     medzi = (Dot(A,B))  / (AbsA * AbsB);
  457.  
  458.     //a nakoniec vypocet uhla
  459.     vysledok =  acosf(medzi);
  460.  
  461.     //nezaporny
  462.     if (vysledok < 0.0f) vysledok = -vysledok;
  463.  
  464.     return vysledok;
  465.  
  466. }
  467.  
  468.  
  469. //------------------------------------------------------------------
  470. // Name: CalcAngleVector()
  471. // Desc: vypocitaj uhol ktore zvieraju dve vektory
  472. //------------------------------------------------------------------
  473. float CalcAngleVector(VECTOR3D P1, VECTOR3D P2)
  474. {
  475.  
  476.     float medzi; //medzivypocet
  477.     float vysledok;  //konecky vysledok
  478.  
  479.     //vypocet absolutnych hodnot vektorov
  480.     float AbsP1 = Absolute(P1);
  481.     float AbsP2 = Absolute(P2);
  482.  
  483.     //skalarny sucin / absolutne hodnoty vektorov
  484.     medzi = (Dot(P1,P2))  / (AbsP1 * AbsP2 );
  485.  
  486.     //a nakoniec vypocet uhla
  487.     vysledok = acosf(medzi);
  488.  
  489.     return vysledok;
  490.  
  491. }
  492.  
  493.  
  494. //------------------------------------------------------------------
  495. // Name: CalcDistance()
  496. // Desc: Vypocet vzdialenosti
  497. //------------------------------------------------------------------
  498. float CalcDistance(VECTOR3D B1,VECTOR3D B2)
  499. {
  500.     VECTOR3D Vec;
  501.  
  502.     Sub(&Vec,B1,B2);
  503.  
  504.     float Abs = Absolute(Vec);
  505.  
  506.     return Abs ;
  507.  
  508. }
  509.  
  510.  
  511. //------------------------------------------------------------------
  512. // Name: TransformPoint()
  513. // Desc: transformuje vector3D 
  514. //------------------------------------------------------------------
  515. VECTOR3D TransformPoint(VECTOR3D Point,D3DXMATRIXA16 Matica)
  516. {
  517.     VECTOR3D Vys;
  518.  
  519.     D3DXVECTOR3 PIn;
  520.     D3DXVECTOR3 POut;
  521.  
  522.     PIn.x = Point.X;
  523.     PIn.y = Point.Y;
  524.     PIn.z = Point.Z;
  525.             
  526.     D3DXVec3TransformCoord( &POut,&PIn,&Matica);
  527.  
  528.     Vys.X = POut.x;
  529.     Vys.Y = POut.y;
  530.     Vys.Z = POut.z;
  531.  
  532.  
  533.     return Vys;
  534.  
  535. }
  536.  
  537.  
  538. //------------------------------------------------------------------
  539. // Name: TransformPlane()
  540. // Desc: transformuje rovinu
  541. //------------------------------------------------------------------
  542. PLANE TransformPlane(PLANE Plane,D3DXMATRIXA16 Matica)
  543. {
  544.     PLANE Vys;
  545.  
  546.     D3DXPLANE PIn;
  547.     D3DXPLANE POut;
  548.  
  549.     PIn.a = Plane.Normal.X;
  550.     PIn.b = Plane.Normal.Y;
  551.     PIn.c = Plane.Normal.Z;
  552.     PIn.d = Plane.D;
  553.  
  554.     D3DXPlaneTransform(&POut,&PIn,&Matica);
  555.  
  556.     Vys.Normal.X = POut.a;
  557.     Vys.Normal.Y = POut.b;
  558.     Vys.Normal.Z = POut.c;
  559.     Vys.D = POut.d;
  560.  
  561.     return Vys;
  562.  
  563. }
  564.  
  565.  
  566. //------------------------------------------------------------------
  567. // Name: TransformNormal()
  568. // Desc: transformuje normalovy vektor
  569. //------------------------------------------------------------------
  570. VECTOR3D TransformNormal(VECTOR3D Point,D3DXMATRIXA16 Matica)
  571. {
  572.     VECTOR3D Vys;
  573.  
  574.     D3DXVECTOR3 PIn;
  575.     D3DXVECTOR3 POut;
  576.  
  577.     PIn.x = Point.X;
  578.     PIn.y = Point.Y;
  579.     PIn.z = Point.Z;
  580.         
  581.     D3DXVec3TransformNormal( &POut,&PIn,&Matica);
  582.  
  583.     Vys.X = POut.x;
  584.     Vys.Y = POut.y;
  585.     Vys.Z = POut.z;
  586.  
  587.     return Vys;
  588.  
  589. }
  590.  
  591.  
  592. //------------------------------------------------------------------
  593. // Name: UnTransformPoint()
  594. // Desc: untransformuje vector3D 
  595. //------------------------------------------------------------------
  596. VECTOR3D UnTransformPoint(VECTOR3D Point,D3DXMATRIXA16 Matica)
  597. {
  598.     VECTOR3D Vys;
  599.  
  600.     D3DXVECTOR3 PIn;
  601.     D3DXVECTOR4 POut;
  602.  
  603.     PIn.x = Point.X;
  604.     PIn.y = Point.Y;
  605.     PIn.z = Point.Z;
  606.  
  607.     D3DXMatrixInverse(&Matica,NULL,&Matica);
  608.  
  609.     D3DXVec3Transform( &POut,&PIn,&Matica);
  610.  
  611.     Vys.X = POut.x;
  612.     Vys.Y = POut.y;
  613.     Vys.Z = POut.z;
  614.  
  615.  
  616.     return Vys;
  617.  
  618. }
  619.  
  620. //------------------------------------------------------------------
  621. // Name: GetMaterial()
  622. // Desc: Vrati material
  623. //------------------------------------------------------------------
  624. D3DMATERIAL9  GetMaterial(COLOR Ambient,
  625.                           COLOR Diffuse,
  626.                           COLOR Specular,
  627.                           COLOR Emissive,float Power)
  628. {
  629.  
  630.     D3DMATERIAL9 Vys;
  631.  
  632.     Vys.Ambient.a = Ambient.A;
  633.     Vys.Ambient.r = Ambient.R;
  634.     Vys.Ambient.g = Ambient.G;
  635.     Vys.Ambient.b = Ambient.B;
  636.  
  637.     Vys.Emissive.a = Emissive.A;
  638.     Vys.Emissive.r = Emissive.R;
  639.     Vys.Emissive.g = Emissive.G;
  640.     Vys.Emissive.b = Emissive.B;
  641.  
  642.     Vys.Diffuse.a = Diffuse.A;
  643.     Vys.Diffuse.r = Diffuse.R;
  644.     Vys.Diffuse.g = Diffuse.G;
  645.     Vys.Diffuse.b = Diffuse.B;
  646.  
  647.     Vys.Specular.a = Specular.A;
  648.     Vys.Specular.r = Specular.R;
  649.     Vys.Specular.g = Specular.G;
  650.     Vys.Specular.b = Specular.B;
  651.  
  652.     Vys.Power = Power;
  653.  
  654.     return Vys;
  655.  
  656.  
  657. }
  658.  
  659. //------------------------------------------------------------------
  660. // Name: CollisionBoxEdge
  661. // Desc: Kolizia medzi kvadrom a useckou
  662. //------------------------------------------------------------------
  663. bool CollisionBoxEdge(VECTOR3D P1,VECTOR3D P2,VECTOR3D Min,VECTOR3D Max)
  664. {
  665.     if(((P1.X < Max.X) && (P2.X > Min.X)) ||
  666.        ((P1.X > Min.X) && (P2.X < Max.X)))
  667.     {
  668.         if(((P1.Y < Max.Y) && (P2.Y > Min.Y)) ||
  669.            ((P1.Y > Min.Y) && (P2.Y < Max.Y)))
  670.         {
  671.  
  672.            if(((P1.Z < Max.Z) && (P2.Z > Min.Z)) ||
  673.               ((P1.Z > Min.Z) && (P2.Z < Max.Z)))
  674.             {
  675.                return true;
  676.             }
  677.         }
  678.     }
  679.  
  680.     return false;
  681.  
  682. }
  683.  
  684. //-----------------------------------------------------------------------------
  685. // Name: FixedToRelative
  686. // Desc: z fixneho rozlisenia sa prepocitavaju suradnice do relativneho 
  687. //-----------------------------------------------------------------------------
  688. float FTRX(float Value)
  689. {
  690.     return (Value/800.0f)*Engine.Width;
  691. }
  692. float FTRY(float Value)
  693. {
  694.     return (Value/600.0f)*Engine.Height;
  695. }
  696.  
  697. //-----------------------------------------------------------------------------
  698. // Name: getRandomMinMax()
  699. // Desc: Gets a random number between min/max boundaries
  700. //-----------------------------------------------------------------------------
  701. float RandomMinMax( float fMin, float fMax )
  702. {
  703.     float fRandNum = (float)rand () / RAND_MAX;
  704.     return fMin + (fMax - fMin) * fRandNum;
  705. }
  706.  
  707. //-----------------------------------------------------------------------------
  708. // Name: RandomVector()
  709. // Desc: Generates a random vector where X,Y, and Z components are between
  710. //       -1.0 and 1.0
  711. //-----------------------------------------------------------------------------
  712. VECTOR3D RandomVector()
  713. {
  714.     VECTOR3D vVector;
  715.  
  716.     // Pick a random Z between -1.0f and 1.0f.
  717.     vVector.Z = RandomMinMax( -1.0f, 1.0f );
  718.     
  719.     // Get radius of this circle
  720.     float radius = (float)sqrt(1 - vVector.Z * vVector.Z);
  721.     
  722.     // Pick a random point on a circle.
  723.     float t = RandomMinMax( -D3DX_PI, D3DX_PI );
  724.  
  725.     // Compute matching X and Y for our Z.
  726.     vVector.X = (float)cosf(t) * radius;
  727.     vVector.Y = (float)sinf(t) * radius;
  728.  
  729.     return vVector;
  730. }
  731.  
  732. //----------------------------------------------------------------
  733. //Name: EnvironmentMapping
  734. //Desc: vypocita texture suradnice pre enviro mapping
  735. //----------------------------------------------------------------
  736. VECTOR2D EnvironmentMapping(VECTOR3D Point,
  737.                             VECTOR3D Normal,
  738.                             float Offset,
  739.                             D3DXMATRIXA16 ViewMatrix)
  740. {
  741.  
  742.     VECTOR2D Vys;
  743.  
  744.     Normal = TransformNormal(Normal,ViewMatrix);
  745.     Point  = TransformPoint (Point,ViewMatrix);    
  746.  
  747.     //tex.u = max_u/2 + normal.x*(max_u/2)
  748.     //tex.v = max_v/2 + normal.y*(max_v/2)
  749.     
  750.     Vys.X = 0.5f + Normal.X*(0.5f)+(Point.X/300.0f);
  751.     Vys.Y = 0.5f + Normal.Y*(0.5f)+(Point.Z/300.0f);
  752.  
  753.     return Vys;            
  754.  
  755. }
  756. //----------------------------------------------------------------
  757. //Name: BumpMapping
  758. //Desc: vypocita texture suradnice pre bump mapping
  759. //----------------------------------------------------------------
  760. VECTOR2D BumpMapping(VECTOR3D Normal, VECTOR2D TexCoor,float Offset, D3DXMATRIXA16 ViewMatrix)
  761. {
  762.  
  763.     VECTOR2D Vys;
  764.  
  765.     VECTOR3D N;
  766.  
  767.     N = TransformNormal(Normal,ViewMatrix);
  768.     
  769.     Vys.X = TexCoor.X + N.X*(Offset);
  770.     Vys.Y = TexCoor.Y + N.Y*(Offset);
  771.  
  772.     return Vys;            
  773.  
  774. }
  775.  
  776. //------------------------------------------------------------------
  777. // Name: GetRotation 
  778. // Desc: zo smeroveho nenormalizovaneho vektoru urobi rotaciu ypr
  779. //------------------------------------------------------------------
  780. VECTOR3D GetRotationLok(VECTOR3D Pos, VECTOR3D Lok)
  781. {
  782.  
  783.     VECTOR3D Rot;
  784.  
  785.     VECTOR3D Sme;
  786.     Sub(&Sme,Lok,Pos);
  787.     Sme.Y = 0.0f;
  788.     Normalize(&Sme);
  789.     
  790.     Rot.Y = asinf(Sme.X);
  791.     if (Sme.Z <= 0.0f)
  792.     {
  793.         Rot.Y = 3.14f - Rot.Y;
  794.     }
  795.  
  796.     Sub(&Sme,Lok,Pos);
  797.     Normalize(&Sme);
  798.     Rot.X = -asinf(Sme.Y);
  799.  
  800.     return Rot ;
  801. }
  802.  
  803. //------------------------------------------------------------------
  804. // Name: GetRotationSme
  805. // Desc: zo smeroveho nenormalizovaneho vektoru urobi rotaciu ypr
  806. //------------------------------------------------------------------
  807. VECTOR3D GetRotationSme(VECTOR3D Sme)
  808. {
  809.  
  810.     VECTOR3D Rot;
  811.     VECTOR3D S;
  812.  
  813.     S = Sme;
  814.     S.Y = 0.0f;
  815.     Normalize(&S);
  816.     
  817.     Rot.Y = asinf(S.X);
  818.     if (S.Z <= 0.0f)
  819.     {
  820.         Rot.Y = 3.14f - Rot.Y;
  821.     }
  822.  
  823.     S = Sme;
  824.     Normalize(&S);
  825.     Rot.X = -asinf(S.Y);
  826.  
  827.     return Rot ;
  828. }
  829.  
  830. //------------------------------------------------------------------
  831. // Name: FPS
  832. // Desc: Funcie pre FPS
  833. //------------------------------------------------------------------
  834. float FPS = 1000.0f;
  835. int   iFPS = 1000;
  836.  
  837. __int64 counter1;
  838. __int64 counter2;
  839. __int64 freq;
  840.  
  841. void TimeStart()
  842. {
  843.     QueryPerformanceCounter((LARGE_INTEGER *)&counter1); 
  844. }
  845.  
  846. void TimeEnd()
  847. {
  848.  
  849.     QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
  850.     QueryPerformanceCounter((LARGE_INTEGER *)&counter2); 
  851.  
  852.     FPS = (float)freq  /  ((float)(counter2-counter1));
  853.     iFPS = (int)FPS;
  854. }
  855.  
  856. float Power(float Value)
  857. {
  858.     return (30.0f/FPS)*Value;
  859. }
  860.  
  861. float PowerTime(float Value)
  862. {
  863.     return (1000.0f/FPS)*Value;
  864. }
  865.